public class DoubleStack<T> {
    private int maxSize;  // 数组的最大容量
    private T[] stackArray;  // 存储栈的数组
    private int top1;  // 栈1的栈顶指针
    private int top2;  // 栈2的栈顶指针

    // 构造函数，初始化数组和栈顶指针
    public DoubleStack(int size) {
        this.maxSize = size;
        this.stackArray = (T[]) new Object[maxSize];
        this.top1 = -1;  // 栈1的栈顶指针初始化为-1
        this.top2 = maxSize;  // 栈2的栈顶指针初始化为maxSize
    }

    // 判断栈1是否为空
    public boolean isStack1Empty() {
        return top1 == -1;
    }

    // 判断栈2是否为空
    public boolean isStack2Empty() {
        return top2 == maxSize;
    }

    // 判断数组是否已满（两个栈的栈顶指针相遇）
    public boolean isFull() {
        return top1 + 1 == top2;
    }

    // 向栈1中压入元素
    public void pushStack1(T element) {
        if (isFull()) {
            System.out.println("栈已满，无法插入元素");
            return;
        }
        stackArray[++top1] = element;  // 栈1的栈顶指针向右移动，并插入元素
    }

    // 向栈2中压入元素
    public void pushStack2(T element) {
        if (isFull()) {
            System.out.println("栈已满，无法插入元素");
            return;
        }
        stackArray[--top2] = element;  // 栈2的栈顶指针向左移动，并插入元素
    }

    // 从栈1中弹出元素
    public T popStack1() {
        if (isStack1Empty()) {
            System.out.println("栈1为空，无法弹出元素");
            return null;
        }
        return stackArray[top1--];  // 返回栈顶元素，并将栈顶指针左移
    }

    // 从栈2中弹出元素
    public T popStack2() {
        if (isStack2Empty()) {
            System.out.println("栈2为空，无法弹出元素");
            return null;
        }
        return stackArray[top2++];  // 返回栈顶元素，并将栈顶指针右移
    }

    // 获取栈1的栈顶元素（不弹出）
    public T peekStack1() {
        if (isStack1Empty()) {
            System.out.println("栈1为空");
            return null;
        }
        return stackArray[top1];
    }

    // 获取栈2的栈顶元素（不弹出）
    public T peekStack2() {
        if (isStack2Empty()) {
            System.out.println("栈2为空");
            return null;
        }
        return stackArray[top2];
    }

    // 打印栈1的内容
    public void printStack1() {
        if (isStack1Empty()) {
            System.out.println("栈1为空");
            return;
        }
        System.out.print("栈1内容：");
        for (int i = 0; i <= top1; i++) {
            System.out.print(stackArray[i] + " ");
        }
        System.out.println();
    }

    // 打印栈2的内容
    public void printStack2() {
        if (isStack2Empty()) {
            System.out.println("栈2为空");
            return;
        }
        System.out.print("栈2内容：");
        for (int i = maxSize - 1; i >= top2; i--) {
            System.out.print(stackArray[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        DoubleStack<Integer> doubleStack = new DoubleStack<>(10);

        // 向栈1和栈2中插入元素
        doubleStack.pushStack1(1);
        doubleStack.pushStack1(2);
        doubleStack.pushStack1(3);

        doubleStack.pushStack2(10);
        doubleStack.pushStack2(20);
        doubleStack.pushStack2(30);

        // 打印栈1和栈2的内容
        doubleStack.printStack1();  // 输出：栈1内容：1 2 3
        doubleStack.printStack2();  // 输出：栈2内容：30 20 10

        // 弹出栈1和栈2的元素
        System.out.println("弹出栈1的元素：" + doubleStack.popStack1());  // 输出：3
        System.out.println("弹出栈2的元素：" + doubleStack.popStack2());  // 输出：30

        // 再次打印栈1和栈2的内容
        doubleStack.printStack1();  // 输出：栈1内容：1 2
        doubleStack.printStack2();  // 输出：栈2内容：20 10
    }
}